package org.jeecg.access.Controller;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.access.constant.PlatformType;
import org.jeecg.access.entity.PlatformTotal;
import org.jeecg.access.platform.entity.XhsUserInfo;
import org.jeecg.access.platform.mapper.XhsUserInfoMapper;
import org.jeecg.access.platform.service.BaseGetDataService;
import org.jeecg.access.service.UnifiedPlatformService;
import org.jeecg.common.api.vo.Result;
import org.jeecg.config.PlatformGetDataFactory;
import org.jeecg.config.PlatformServiceRegistry;
import org.jeecg.util.DateTimeUtil;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @description: 微信平台数据统计控制器
 * @author: taogang
 * @date: 2025/7/15 14:47
 */
@Slf4j
@RestController
@RequestMapping("/platformData")
@Api(tags = "微信数据同步接口")
public class PlatformDataController {

    private final PlatformServiceRegistry serviceRegistry;


    private final PlatformGetDataFactory getDataFactory;

    private final XhsUserInfoMapper xhsUserInfoMapper;

    @Autowired
    public PlatformDataController(PlatformServiceRegistry serviceRegistry,XhsUserInfoMapper xhsUserInfoMapper,
                                  PlatformGetDataFactory getDataFactory) {
        this.serviceRegistry = serviceRegistry;
        this.xhsUserInfoMapper = xhsUserInfoMapper;
        this.getDataFactory = getDataFactory;
    }

    /**
     * 获取平台账号总数统计
     */
    @GetMapping("/accountTotal")
    public Result<List<PlatformTotal>> getAccountTotal() {
        List<PlatformTotal> result = serviceRegistry.getAllServices().stream()
                .map(UnifiedPlatformService::getAccountTotal)
                .collect(Collectors.toList());

        return Result.OK(result);
    }

    @GetMapping("/platformTotal")
    public Result<Object> getPlatformTotal(@RequestParam("platformType") String platformType) {

        UnifiedPlatformService service = serviceRegistry.getService(platformType);
        if (service == null) {
            log.warn("不支持的平台类型: {}", platformType);
            return Result.error("不支持的平台类型");
        }

        return Result.OK(service.getPlatformTotal());
    }

    /**
     * 获取平台详细数据
     */
    @GetMapping("/detailData")
    public Result<Object> getPlatformDetailData(
            @RequestParam("platformType") String platformType) {

        UnifiedPlatformService service = serviceRegistry.getService(platformType);
        if (service == null) {
            log.warn("不支持的平台类型: {}", platformType);
            return Result.error("不支持的平台类型");
        }

        Object data = service.getPlatformDetailData();
        // 确保返回空集合而非null
        if (data instanceof Collection) {
            return Result.OK(((Collection<?>) data).isEmpty() ? Collections.emptyList() : data);
        }
        return Result.OK(data);
    }

    @PostMapping("/getAllWordData")
    public void getAllWordData(){
        // 获取所有平台的数据服务
        Map<String, BaseGetDataService> dataServiceMap = getDataFactory.getServiceMap();
        log.info("获取到 {} 个平台的数据服务，开始执行数据保存操作", dataServiceMap.size());

        // 遍历所有数据服务，执行保存操作（使用entrySet遍历，避免重复get操作）
        Set<Map.Entry<String, BaseGetDataService>> serviceEntries = dataServiceMap.entrySet();
        for (Map.Entry<String, BaseGetDataService> entry : serviceEntries) {
            String platformType = entry.getKey();
            BaseGetDataService dataService = entry.getValue();

            log.info("开始处理 [{}] 平台的数据", platformType);

            // 保存作品数据（单独捕获异常，避免影响其他操作）
            try {
                log.debug("[{}] 平台开始保存作品数据", platformType);
                dataService.saveWorksData(1);
                log.debug("[{}] 平台作品数据保存完成", platformType);
            } catch (Exception e) {
                log.error("[{}] 平台保存作品数据失败", platformType, e);
            }

            log.info("[{}] 平台数据处理结束", platformType);
        }

        log.info("====== 平台数据获取定时任务执行完成 ======");
    }

    @PostMapping("/dataByPlatformType")
    public void getDataByPlatformType(@RequestBody Map<String, Object> requestParams){
        // 从请求参数中提取平台类型和第三方参数（param为String类型）
        String platformType = (String) requestParams.get("platformType");
        String param = (String) requestParams.get("param"); // 改为String类型

        // 获取所有平台的数据服务
        Map<String, BaseGetDataService> dataServiceMap = getDataFactory.getServiceMap();
        log.info("获取到 {} 个平台的数据服务，开始执行数据保存操作", dataServiceMap.size());

        // 如果未指定平台类型，不执行任何操作
        if (platformType == null || platformType.trim().isEmpty()) {
            log.info("未指定平台类型（platformType为空），不执行任何数据处理操作");
            return;
        }

        if(platformType != null && !platformType.trim().isEmpty()
                && null != param && !param.trim().isEmpty()){

            // 构造更新条件：state = 0
            UpdateWrapper<XhsUserInfo> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("state", 0); // 条件：state等于0

            // 构造更新内容：cookie = param
            XhsUserInfo updateEntity = new XhsUserInfo();
            updateEntity.setCookie(param); // 设置要更新的cookie值
            updateEntity.setUpdateTime(DateTimeUtil.getCurrentTimestamp());
            // 执行更新操作（where条件由wrapper指定，更新内容由entity指定）
            int updateCount = xhsUserInfoMapper.update(updateEntity, updateWrapper);

            log.info("成功更新 {} 条state=0的记录的cookie值", updateCount);
        }

        // 遍历所有数据服务，执行保存操作
        Set<Map.Entry<String, BaseGetDataService>> serviceEntries = dataServiceMap.entrySet();
        for (Map.Entry<String, BaseGetDataService> entry : serviceEntries) {
            String currentPlatform = entry.getKey();
            BaseGetDataService dataService = entry.getValue();

            // 判断是否需要处理当前平台：仅当平台类型匹配时才执行
            boolean shouldProcess = platformType.equals(currentPlatform);

            if (!shouldProcess) {
                log.debug("跳过 [{}] 平台，指定执行平台为 [{}]", currentPlatform, platformType);
                continue;
            }

            log.info("开始处理 [{}] 平台的数据", currentPlatform);

            // 保存用户信息（仅在平台匹配时执行，并传入String参数）
            try {
                log.debug("[{}] 平台开始保存用户信息", currentPlatform);
                // 无需额外判断平台类型，因为外层已经确认匹配
                dataService.saveUserInfo();
                log.debug("[{}] 平台用户信息保存完成", currentPlatform);
            } catch (Exception e) {
                log.error("[{}] 平台保存用户信息失败", currentPlatform, e);
            }

            // 保存作品数据（仅在平台匹配时执行，并传入String参数）
            try {
                log.debug("[{}] 平台开始保存作品数据", currentPlatform);
                // 无需额外判断平台类型，因为外层已经确认匹配
                dataService.saveWorksData(0);
                log.debug("[{}] 平台作品数据保存完成", currentPlatform);
            } catch (Exception e) {
                log.error("[{}] 平台保存作品数据失败", currentPlatform, e);
            }
            log.info("[{}] 平台数据处理结束", currentPlatform);
        }
    }
}